package com.issoft.studentresitor.utils;

import com.auth0.jwt.JWT;
import com.auth0.jwt.JWTVerifier;
import com.auth0.jwt.algorithms.Algorithm;
import com.auth0.jwt.exceptions.JWTVerificationException;
import com.auth0.jwt.interfaces.DecodedJWT;

import java.util.Date;
import java.util.Map;

public class JwtUtils {

    // 使用与测试类一致的密钥
    private static final String SECRET_KEY = "YWlsYW4=";

    // 12小时的过期时间（单位：毫秒）
    private static final long EXPIRATION = 12 * 60 * 60 * 1000;

    // 算法
    private static final Algorithm ALGORITHM = Algorithm.HMAC256(SECRET_KEY);

    // 验证器
    private static final JWTVerifier VERIFIER = JWT.require(ALGORITHM).build();

    /**
     * 生成JWT令牌
     *
     * @param claims 自定义负载信息
     * @return 生成的token字符串
     */
    public static String generateToken(Map<String, Object> claims) {
        long now = System.currentTimeMillis();
        long exp = now + EXPIRATION;

        com.auth0.jwt.JWTCreator.Builder builder = JWT.create()
                .withIssuedAt(new Date(now)) // 签发时间
                .withExpiresAt(new Date(exp)); // 过期时间

        // 添加自定义声明
        for (Map.Entry<String, Object> entry : claims.entrySet()) {
            if (entry.getValue() instanceof String) {
                builder.withClaim(entry.getKey(), (String) entry.getValue());
            } else if (entry.getValue() instanceof Integer) {
                builder.withClaim(entry.getKey(), (Integer) entry.getValue());
            } else if (entry.getValue() instanceof Long) {
                builder.withClaim(entry.getKey(), (Long) entry.getValue());
            } else if (entry.getValue() instanceof Boolean) {
                builder.withClaim(entry.getKey(), (Boolean) entry.getValue());
            } else {
                builder.withClaim(entry.getKey(), entry.getValue().toString());
            }
        }

        return builder.sign(ALGORITHM);
    }

    /**
     * 解析JWT令牌，获取声明信息
     *
     * @param token 需要解析的token字符串
     * @return 包含用户信息的DecodedJWT对象
     */
    public static DecodedJWT parseToken(String token) {
        return VERIFIER.verify(token);
    }

    /**
     * 验证JWT令牌是否有效
     *
     * @param token 需要验证的token字符串
     * @return 验证结果，true表示有效，false表示无效
     */
    public static boolean validateToken(String token) {
        try {
            VERIFIER.verify(token);
            return true;
        } catch (JWTVerificationException e) {
            return false;
        }
    }

    /**
     * 从token中获取指定的声明值
     *
     * @param token token字符串
     * @param claimName 声明名称
     * @return 声明值
     */
    public static String getClaimFromToken(String token, String claimName) {
        DecodedJWT jwt = parseToken(token);
        return jwt.getClaim(claimName).asString();
    }

    /**
     * 从token中获取用户ID
     *
     * @param token token字符串
     * @return 用户ID
     */
    public static Integer getUserIdFromToken(String token) {
        DecodedJWT jwt = parseToken(token);
        return jwt.getClaim("id").asInt();
    }

    /**
     * 从token中获取用户名
     *
     * @param token token字符串
     * @return 用户名
     */
    public static String getUsernameFromToken(String token) {
        DecodedJWT jwt = parseToken(token);
        return jwt.getClaim("username").asString();
    }
}
